/*
 * Copyright (C) 2020  Prasoon Joshi
 *
 *     This program is free software: you can redistribute it and/or modify
 *     it under the terms of the GNU General Public License as published by
 *     the Free Software Foundation, either version 3 of the License, or
 *     (at your option) any later version.
 *
 *     This program is distributed in the hope that it will be useful,
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *     GNU General Public License for more details.
 *
 *     You should have received a copy of the GNU General Public License
 *     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

// Generated by <a href="http://scalaxb.org/">scalaxb</a>.
package generated


case class Ead(control: Control,
               archdesc: ArchDescription,
               attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val relatedencoding = attributes.get("@relatedencoding") map { _.as[String]}
  lazy val base = attributes.get("@base") map { _.as[java.net.URI]}
}

      

sealed trait Langencoding

object Langencoding {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Langencoding]): Langencoding = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Langencoding) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Langencoding] = Seq(Iso639u451, Iso639u452b, Iso639u453, Otherlangencoding)
}

case object Iso639u451 extends Langencoding { override def toString = "iso639-1" }
case object Iso639u452b extends Langencoding { override def toString = "iso639-2b" }
case object Iso639u453 extends Langencoding { override def toString = "iso639-3" }
case object Otherlangencoding extends Langencoding { override def toString = "otherlangencoding" }

sealed trait Scriptencoding

object Scriptencoding {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Scriptencoding]): Scriptencoding = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Scriptencoding) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Scriptencoding] = Seq(Iso15924, Otherscriptencoding)
}

case object Iso15924 extends Scriptencoding { override def toString = "iso15924" }
case object Otherscriptencoding extends Scriptencoding { override def toString = "otherscriptencoding" }

sealed trait Dateencoding

object Dateencoding {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Dateencoding]): Dateencoding = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Dateencoding) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Dateencoding] = Seq(Iso8601, Otherdateencoding)
}

case object Iso8601 extends Dateencoding { override def toString = "iso8601" }
case object Otherdateencoding extends Dateencoding { override def toString = "otherdateencoding" }

sealed trait Countryencoding

object Countryencoding {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Countryencoding]): Countryencoding = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Countryencoding) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Countryencoding] = Seq(Iso3166u451, Othercountryencoding)
}

case object Iso3166u451 extends Countryencoding { override def toString = "iso3166-1" }
case object Othercountryencoding extends Countryencoding { override def toString = "othercountryencoding" }

sealed trait Repositoryencoding

object Repositoryencoding {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Repositoryencoding]): Repositoryencoding = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Repositoryencoding) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Repositoryencoding] = Seq(Iso15511, Otherrepositoryencoding)
}

case object Iso15511 extends Repositoryencoding { override def toString = "iso15511" }
case object Otherrepositoryencoding extends Repositoryencoding { override def toString = "otherrepositoryencoding" }


case class Control(recordid: Recordid,
  otherrecordid: Seq[Otherrecordid] = Nil,
  representation: Seq[Representation] = Nil,
  filedesc: Filedesc,
  maintenancestatus: Maintenancestatus,
  publicationstatus: Option[Publicationstatus] = None,
  maintenanceagency: Maintenanceagency,
  languagedeclaration: Seq[Languagedeclaration] = Nil,
  conventiondeclaration: Seq[Conventiondeclaration] = Nil,
  rightsdeclaration: Seq[Rightsdeclaration] = Nil,
  localtypedeclaration: Seq[Localtypedeclaration] = Nil,
  localcontrol: Seq[Localcontrol] = Nil,
  maintenancehistory: Maintenancehistory,
  sources: Option[Sources] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val relatedencoding = attributes.get("@relatedencoding") map { _.as[String]}
  lazy val base = attributes.get("@base") map { _.as[java.net.URI]}
  lazy val langencoding = attributes.get("@langencoding") map { _.as[Langencoding]}
  lazy val scriptencoding = attributes.get("@scriptencoding") map { _.as[Scriptencoding]}
  lazy val dateencoding = attributes.get("@dateencoding") map { _.as[Dateencoding]}
  lazy val countryencoding = attributes.get("@countryencoding") map { _.as[Countryencoding]}
  lazy val repositoryencoding = attributes.get("@repositoryencoding") map { _.as[Repositoryencoding]}
}

      


case class Recordid(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val instanceurl = attributes.get("@instanceurl") map { _.as[java.net.URI]}
}

      


case class Otherrecordid(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      


case class Representation(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val href = attributes.get("@href") map { _.as[String]}
  lazy val linkrole = attributes.get("@linkrole") map { _.as[java.net.URI]}
  lazy val arcrole = attributes.get("@arcrole") map { _.as[java.net.URI]}
  lazy val linktitle = attributes.get("@linktitle") map { _.as[String]}
  lazy val show = attributes.get("@show") map { _.as[ShowType]}
  lazy val actuate = attributes.get("@actuate") map { _.as[ActuateType]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      


case class Filedesc(titlestmt: Titlestmt,
  editionstmt: Option[Editionstmt] = None,
  publicationstmt: Option[Publicationstmt] = None,
  seriesstmt: Option[Seriesstmt] = None,
  notestmt: Option[Notestmt] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Titlestmt(titleproper: Seq[Titleproper] = Nil,
  subtitle: Seq[Subtitle] = Nil,
  author: Seq[Author] = Nil,
  sponsor: Seq[Sponsor] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Editionstmt(editionstmtoption: Seq[scalaxb.DataRecord[EditionstmtOption]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait EditionstmtOption

case class Publicationstmt(publicationstmtoption: Seq[scalaxb.DataRecord[PublicationstmtOption]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait PublicationstmtOption

case class Seriesstmt(seriesstmtoption: Seq[scalaxb.DataRecord[SeriesstmtOption]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait SeriesstmtOption

case class Notestmt(controlnote: Seq[Controlnote] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

sealed trait Value

object Value {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Value]): Value = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Value) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Value] = Seq(Revised, Deleted, New, Deletedsplit, Deletedmerged, Deletedreplaced, Cancelled, Derived)
}

case object Revised extends Value { override def toString = "revised" }
case object Deleted extends Value { override def toString = "deleted" }
case object New extends Value { override def toString = "new" }
case object Deletedsplit extends Value { override def toString = "deletedsplit" }
case object Deletedmerged extends Value { override def toString = "deletedmerged" }
case object Deletedreplaced extends Value { override def toString = "deletedreplaced" }
case object Cancelled extends Value { override def toString = "cancelled" }
case object Derived extends Value { override def toString = "derived" }


case class Maintenancestatus(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val valueAttribute = attributes("@value").as[Value]
}

      

sealed trait ValueType

object ValueType {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[ValueType]): ValueType = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: ValueType) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[ValueType] = Seq(Inprocess, Approved, Published)
}

case object Inprocess extends ValueType { override def toString = "inprocess" }
case object Approved extends ValueType { override def toString = "approved" }
case object Published extends ValueType { override def toString = "published" }


case class Publicationstatus(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val valueAttribute = attributes("@value").as[ValueType]
}

      


case class Languagedeclaration(language: Language,
  scriptElement: Script,
  descriptivenote: Option[Descriptivenote] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Conventiondeclaration(abbr: Option[Abbr] = None,
  citation: Citation,
  descriptivenote: Option[Descriptivenote] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      


case class Rightsdeclaration(abbr: Option[Abbr] = None,
  citation: Citation,
  descriptivenote: Option[Descriptivenote] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      


case class Localtypedeclaration(abbr: Option[Abbr] = None,
  citation: Citation,
  descriptivenote: Option[Descriptivenote] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Localcontrol(term: Option[Term] = None,
  localcontroloption: Option[scalaxb.DataRecord[LocalcontrolOption]] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      

trait LocalcontrolOption

case class Term(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val transliteration = attributes.get("@transliteration") map { _.as[String]}
  lazy val lastdatetimeverified = attributes.get("@lastdatetimeverified") map { _.as[String]}
  lazy val source = attributes.get("@source") map { _.as[String]}
  lazy val rules = attributes.get("@rules") map { _.as[String]}
  lazy val identifier = attributes.get("@identifier") map { _.as[String]}
}

      


case class Maintenancehistory(maintenanceevent: Seq[Maintenanceevent] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Maintenanceevent(eventtype: Eventtype,
  eventdatetime: Eventdatetime,
  agenttype: Agenttype,
  agent: Agent,
  eventdescription: Seq[Eventdescription] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

sealed trait ValueType2

object ValueType2 {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[ValueType2]): ValueType2 = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: ValueType2) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[ValueType2] = Seq(Created, RevisedValue, DeletedValue, CancelledValue, DerivedValue, Updated, Unknown)
}

case object Created extends ValueType2 { override def toString = "created" }
case object RevisedValue extends ValueType2 { override def toString = "revised" }
case object DeletedValue extends ValueType2 { override def toString = "deleted" }
case object CancelledValue extends ValueType2 { override def toString = "cancelled" }
case object DerivedValue extends ValueType2 { override def toString = "derived" }
case object Updated extends ValueType2 { override def toString = "updated" }
case object Unknown extends ValueType2 { override def toString = "unknown" }


case class Eventtype(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val valueAttribute = attributes("@value").as[ValueType2]
}

      


case class Eventdatetime(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val standarddatetime = attributes.get("@standarddatetime") map { _.as[String]}
}

      

sealed trait ValueType3

object ValueType3 {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[ValueType3]): ValueType3 = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: ValueType3) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[ValueType3] = Seq(Human, Machine, UnknownValue)
}

case object Human extends ValueType3 { override def toString = "human" }
case object Machine extends ValueType3 { override def toString = "machine" }
case object UnknownValue extends ValueType3 { override def toString = "unknown" }


case class Agenttype(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val valueAttribute = attributes("@value").as[ValueType3]
}

      


case class Agent(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Eventdescription(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      


case class Sources(source: Seq[Source] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val base = attributes.get("@base") map { _.as[java.net.URI]}
}

      


case class Source(sourceentry: Seq[Sourceentry] = Nil,
  objectxmlwrap: Option[Objectxmlwrap] = None,
  descriptivenote: Option[Descriptivenote] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val lastdatetimeverified = attributes.get("@lastdatetimeverified") map { _.as[String]}
  lazy val href = attributes.get("@href") map { _.as[String]}
  lazy val linkrole = attributes.get("@linkrole") map { _.as[java.net.URI]}
  lazy val arcrole = attributes.get("@arcrole") map { _.as[java.net.URI]}
  lazy val linktitle = attributes.get("@linktitle") map { _.as[String]}
  lazy val show = attributes.get("@show") map { _.as[ShowType]}
  lazy val actuate = attributes.get("@actuate") map { _.as[ActuateType]}
}

      


case class Sourceentry(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val transliteration = attributes.get("@transliteration") map { _.as[String]}
}

      

sealed trait Render

object Render {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Render]): Render = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Render) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Render] = Seq(Altrender, Bold, Bolddoublequote, Bolditalic, Boldsinglequote, Boldsmcaps, Boldunderline, Doublequote, Italic, Nonproport, Singlequote, Smcaps, Sub, Super, Underline)
}

case object Altrender extends Render { override def toString = "altrender" }
case object Bold extends Render { override def toString = "bold" }
case object Bolddoublequote extends Render { override def toString = "bolddoublequote" }
case object Bolditalic extends Render { override def toString = "bolditalic" }
case object Boldsinglequote extends Render { override def toString = "boldsinglequote" }
case object Boldsmcaps extends Render { override def toString = "boldsmcaps" }
case object Boldunderline extends Render { override def toString = "boldunderline" }
case object Doublequote extends Render { override def toString = "doublequote" }
case object Italic extends Render { override def toString = "italic" }
case object Nonproport extends Render { override def toString = "nonproport" }
case object Singlequote extends Render { override def toString = "singlequote" }
case object Smcaps extends Render { override def toString = "smcaps" }
case object Sub extends Render { override def toString = "sub" }
case object Super extends Render { override def toString = "super" }
case object Underline extends Render { override def toString = "underline" }


case class Titleproper(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable with SeriesstmtOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val render = attributes.get("@render") map { _.as[Render]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Subtitle(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Author(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Sponsor(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Edition(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable with EditionstmtOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Publisher(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable with PublicationstmtOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Controlnote(mu46blocksOption1: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Maintenanceagency(agencycode: Option[Agencycode] = None,
  otheragencycode: Seq[Otheragencycode] = Nil,
  agencyname: Seq[Agencyname] = Nil,
  descriptivenote: Option[Descriptivenote] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val countrycode = attributes.get("@countrycode") map { _.as[String]}
}

      


case class Agencycode(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      


case class Otheragencycode(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      


case class Agencyname(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      


case class Citation(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val href = attributes.get("@href") map { _.as[String]}
  lazy val linkrole = attributes.get("@linkrole") map { _.as[java.net.URI]}
  lazy val arcrole = attributes.get("@arcrole") map { _.as[java.net.URI]}
  lazy val linktitle = attributes.get("@linktitle") map { _.as[String]}
  lazy val show = attributes.get("@show") map { _.as[ShowType]}
  lazy val actuate = attributes.get("@actuate") map { _.as[ActuateType]}
  lazy val lastdatetimeverified = attributes.get("@lastdatetimeverified") map { _.as[String]}
}

      


case class ArchDescription(did: Did,
                           archdescoption: Seq[scalaxb.DataRecord[Any]] = Nil,
                           attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val relatedencoding = attributes.get("@relatedencoding") map { _.as[String]}
  lazy val otherlevel = attributes.get("@otherlevel") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val level = attributes("@level").as[LevelType]
  lazy val base = attributes.get("@base") map { _.as[java.net.URI]}
}

      

trait ArchdescOption

case class Did(head: Option[Head] = None,
  mu46didOption2: Seq[scalaxb.DataRecord[Mu46didOption]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Abstract(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicu46plusu46accessable with Mu46didOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val label = attributes.get("@label") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Container(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable with Mu46didOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val label = attributes.get("@label") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val parent = attributes.get("@parent") map { _.as[Seq[String]]}
  lazy val containerid = attributes.get("@containerid") map { _.as[String]}
}

      

sealed trait Daotype

object Daotype {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Daotype]): Daotype = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Daotype) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Daotype] = Seq(Borndigital, DerivedValue2, UnknownValue2, Otherdaotype)
}

case object Borndigital extends Daotype { override def toString = "borndigital" }
case object DerivedValue2 extends Daotype { override def toString = "derived" }
case object UnknownValue2 extends Daotype { override def toString = "unknown" }
case object Otherdaotype extends Daotype { override def toString = "otherdaotype" }

sealed trait Coverage

object Coverage {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Coverage]): Coverage = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Coverage) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Coverage] = Seq(Whole, PartValue)
}

case object Whole extends Coverage { override def toString = "whole" }
case object PartValue extends Coverage { override def toString = "part" }


case class Dao(descriptivenote: Option[Descriptivenote] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46didOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val label = attributes.get("@label") map { _.as[String]}
  lazy val href = attributes.get("@href") map { _.as[String]}
  lazy val linkrole = attributes.get("@linkrole") map { _.as[java.net.URI]}
  lazy val arcrole = attributes.get("@arcrole") map { _.as[java.net.URI]}
  lazy val linktitle = attributes.get("@linktitle") map { _.as[String]}
  lazy val show = attributes.get("@show") map { _.as[ShowType]}
  lazy val actuate = attributes.get("@actuate") map { _.as[ActuateType]}
  lazy val identifier = attributes.get("@identifier") map { _.as[String]}
  lazy val xpointer = attributes.get("@xpointer") map { _.as[String]}
  lazy val entityref = attributes.get("@entityref") map { _.as[String]}
  lazy val daotype = attributes("@daotype").as[Daotype]
  lazy val otherdaotype = attributes.get("@otherdaotype") map { _.as[String]}
  lazy val coverage = attributes.get("@coverage") map { _.as[Coverage]}
}

      

sealed trait CoverageType

object CoverageType {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[CoverageType]): CoverageType = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: CoverageType) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[CoverageType] = Seq(WholeValue, PartValue2)
}

case object WholeValue extends CoverageType { override def toString = "whole" }
case object PartValue2 extends CoverageType { override def toString = "part" }


case class Daoset(daoFirst: Dao,
  daoOthers: Seq[Dao] = Nil,
  descriptivenote: Option[Descriptivenote] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46didOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val label = attributes.get("@label") map { _.as[String]}
  lazy val coverage = attributes.get("@coverage") map { _.as[CoverageType]}
  lazy val base = attributes.get("@base") map { _.as[java.net.URI]}
}

      


case class Didnote(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable with Mu46didOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val label = attributes.get("@label") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Langmaterial(langmaterialoption: Seq[scalaxb.DataRecord[LangmaterialOption]] = Nil,
  descriptivenote: Option[Descriptivenote] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46didOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val label = attributes.get("@label") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait LangmaterialOption

case class Materialspec(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable with Mu46didOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val label = attributes.get("@label") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      

sealed trait CoverageType2

object CoverageType2 {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[CoverageType2]): CoverageType2 = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: CoverageType2) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[CoverageType2] = Seq(WholeValue2, PartValue3)
}

case object WholeValue2 extends CoverageType2 { override def toString = "whole" }
case object PartValue3 extends CoverageType2 { override def toString = "part" }


case class Physdescset(physdescstructuredFirst: Physdescstructured,
  physdescstructuredOthers: Seq[Physdescstructured] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46didOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val label = attributes.get("@label") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val parallel = attributes.get("@parallel") map { _.as[Avu46boolean]}
  lazy val coverage = attributes.get("@coverage") map { _.as[CoverageType2]}
}

      


case class Physdesc(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable with Mu46didOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val label = attributes.get("@label") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Physloc(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable with Mu46didOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val label = attributes.get("@label") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val parent = attributes.get("@parent") map { _.as[Seq[String]]}
}

      


case class Origination(originationoption: Seq[scalaxb.DataRecord[OriginationOption]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46didOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val label = attributes.get("@label") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait OriginationOption
sealed trait Physdescstructuredtype

object Physdescstructuredtype {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Physdescstructuredtype]): Physdescstructuredtype = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Physdescstructuredtype) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Physdescstructuredtype] = Seq(Carrier, Materialtype, Spaceoccupied, Otherphysdescstructuredtype)
}

case object Carrier extends Physdescstructuredtype { override def toString = "carrier" }
case object Materialtype extends Physdescstructuredtype { override def toString = "materialtype" }
case object Spaceoccupied extends Physdescstructuredtype { override def toString = "spaceoccupied" }
case object Otherphysdescstructuredtype extends Physdescstructuredtype { override def toString = "otherphysdescstructuredtype" }


case class Physdescstructured(quantity: Quantity,
  unittype: Unittype,
  physdescstructuredoption: Seq[scalaxb.DataRecord[PhysdescstructuredOption]] = Nil,
  descriptivenote: Option[Descriptivenote] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46didOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val label = attributes.get("@label") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val physdescstructuredtype = attributes("@physdescstructuredtype").as[Physdescstructuredtype]
  lazy val otherphysdescstructuredtype = attributes.get("@otherphysdescstructuredtype") map { _.as[String]}
  lazy val coverage = attributes("@coverage").as[CoverageType3]
}

      

trait PhysdescstructuredOption

case class Quantity(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val approximate = attributes.get("@approximate") map { _.as[Avu46boolean]}
}

      


case class Unittype(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val source = attributes.get("@source") map { _.as[String]}
  lazy val rules = attributes.get("@rules") map { _.as[String]}
  lazy val identifier = attributes.get("@identifier") map { _.as[String]}
}

      


case class Repository(repositoryoption: Seq[scalaxb.DataRecord[RepositoryOption]] = Nil,
  address: Option[Address] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46didOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val label = attributes.get("@label") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait RepositoryOption

case class Unitdate(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable with Mu46didOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val label = attributes.get("@label") map { _.as[String]}
  lazy val unitdatetype = attributes.get("@unitdatetype") map { _.as[Unitdatetype]}
  lazy val datechar = attributes.get("@datechar") map { _.as[String]}
  lazy val certainty = attributes.get("@certainty") map { _.as[String]}
  lazy val era = attributes.get("@era") map { _.as[String]}
  lazy val calendar = attributes.get("@calendar") map { _.as[String]}
  lazy val normal = attributes.get("@normal") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Unitdatestructured(unitdatestructuredoption: scalaxb.DataRecord[UnitdatestructuredOption],
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46didOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val label = attributes.get("@label") map { _.as[String]}
  lazy val unitdatetype = attributes.get("@unitdatetype") map { _.as[Unitdatetype]}
  lazy val datechar = attributes.get("@datechar") map { _.as[String]}
  lazy val certainty = attributes.get("@certainty") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val era = attributes.get("@era") map { _.as[String]}
  lazy val calendar = attributes.get("@calendar") map { _.as[String]}
}

      

trait UnitdatestructuredOption

case class Unittitle(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicu46plusu46accessable with Mu46didOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val label = attributes.get("@label") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val normal = attributes.get("@normal") map { _.as[String]}
}

      


case class Unitid(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable with Mu46didOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val label = attributes.get("@label") map { _.as[String]}
  lazy val countrycode = attributes.get("@countrycode") map { _.as[String]}
  lazy val repositorycode = attributes.get("@repositorycode") map { _.as[String]}
  lazy val identifier = attributes.get("@identifier") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Accessrestrict(head: Option[Head] = None,
  accessrestrictoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends AccessrestrictOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      

trait AccessrestrictOption

case class Accruals(head: Option[Head] = None,
  accrualsoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends AccrualsOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait AccrualsOption

case class Acqinfo(head: Option[Head] = None,
  acqinfooption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends AcqinfoOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait AcqinfoOption

case class Altformavail(head: Option[Head] = None,
  altformavailoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends AltformavailOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      

trait AltformavailOption

case class Appraisal(head: Option[Head] = None,
  appraisaloption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends AppraisalOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait AppraisalOption

case class Arrangement(head: Option[Head] = None,
  arrangementoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends ArrangementOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait ArrangementOption

case class Bibliography(head: Option[Head] = None,
  bibliographyoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends BibliographyOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait BibliographyOption

case class Bioghist(head: Option[Head] = None,
  bioghistoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends BioghistOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait BioghistOption

case class Controlaccess(head: Option[Head] = None,
  controlaccessoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends ControlaccessOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait ControlaccessOption

case class Custodhist(head: Option[Head] = None,
  custodhistoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends CustodhistOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait CustodhistOption

case class Fileplan(head: Option[Head] = None,
  fileplanoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends FileplanOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait FileplanOption

case class Index(head: Option[Head] = None,
  mu46blocksOption2: Seq[scalaxb.DataRecord[Any]] = Nil,
  indexoption: Seq[scalaxb.DataRecord[IndexOption]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends IndexOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait IndexOption
case class IndexSequence1(listhead: Option[Listhead] = None,
  indexentry: Seq[Indexentry] = Nil) extends IndexOption


case class Indexentry(indexentryoption: scalaxb.DataRecord[Any],
  indexentryoption2: Option[scalaxb.DataRecord[Any]] = None,
  indexentry: Seq[Indexentry] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
}

      

trait IndexentryOption2
trait IndexentryOption

case class Namegrp(mu46accessOption1: Seq[scalaxb.DataRecord[Mu46accessOption]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends IndexentryOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
}

      


case class Ptrgrp(mu46refsOption1: Seq[scalaxb.DataRecord[Mu46refsOption]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends IndexentryOption2 {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
}

      


case class Legalstatus(head: Option[Head] = None,
  legalstatusoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends LegalstatusOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      

trait LegalstatusOption

case class Odd(head: Option[Head] = None,
  oddoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends OddOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait OddOption

case class Originalsloc(head: Option[Head] = None,
  originalslocoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends OriginalslocOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      

trait OriginalslocOption

case class Otherfindaid(head: Option[Head] = None,
  otherfindaidoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends OtherfindaidOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait OtherfindaidOption

case class Phystech(head: Option[Head] = None,
  phystechoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends PhystechOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      

trait PhystechOption

case class Prefercite(head: Option[Head] = None,
  preferciteoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends PreferciteOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait PreferciteOption

case class Processinfo(head: Option[Head] = None,
  processinfooption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends ProcessinfoOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait ProcessinfoOption

case class Relatedmaterial(head: Option[Head] = None,
  relatedmaterialoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends RelatedmaterialOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait RelatedmaterialOption

case class Scopecontent(head: Option[Head] = None,
  scopecontentoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends ScopecontentOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait ScopecontentOption

case class Separatedmaterial(head: Option[Head] = None,
  separatedmaterialoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends SeparatedmaterialOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

trait SeparatedmaterialOption

case class Userestrict(head: Option[Head] = None,
  userestrictoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends UserestrictOption with Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      

trait UserestrictOption

case class Corpname(part: Seq[Part] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends OriginationOption with RepositoryOption with Mu46accessOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val source = attributes.get("@source") map { _.as[String]}
  lazy val rules = attributes.get("@rules") map { _.as[String]}
  lazy val identifier = attributes.get("@identifier") map { _.as[String]}
  lazy val normal = attributes.get("@normal") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val relator = attributes.get("@relator") map { _.as[String]}
}

      


case class Famname(part: Seq[Part] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends OriginationOption with RepositoryOption with Mu46accessOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val source = attributes.get("@source") map { _.as[String]}
  lazy val rules = attributes.get("@rules") map { _.as[String]}
  lazy val identifier = attributes.get("@identifier") map { _.as[String]}
  lazy val normal = attributes.get("@normal") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val relator = attributes.get("@relator") map { _.as[String]}
}

      


case class FunctionType(part: Seq[Part] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46accessOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val source = attributes.get("@source") map { _.as[String]}
  lazy val rules = attributes.get("@rules") map { _.as[String]}
  lazy val identifier = attributes.get("@identifier") map { _.as[String]}
  lazy val normal = attributes.get("@normal") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val relator = attributes.get("@relator") map { _.as[String]}
}

      


case class Genreform(part: Seq[Part] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46accessOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val source = attributes.get("@source") map { _.as[String]}
  lazy val rules = attributes.get("@rules") map { _.as[String]}
  lazy val identifier = attributes.get("@identifier") map { _.as[String]}
  lazy val normal = attributes.get("@normal") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val relator = attributes.get("@relator") map { _.as[String]}
}

      


case class Geogname(part: Seq[Part] = Nil,
  geographiccoordinates: Seq[Geographiccoordinates] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46accessOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val source = attributes.get("@source") map { _.as[String]}
  lazy val rules = attributes.get("@rules") map { _.as[String]}
  lazy val identifier = attributes.get("@identifier") map { _.as[String]}
  lazy val normal = attributes.get("@normal") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val relator = attributes.get("@relator") map { _.as[String]}
}

      


case class Geographiccoordinates(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val coordinatesystem = attributes("@coordinatesystem").as[String]
}

      


case class Name(part: Seq[Part] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends OriginationOption with RepositoryOption with Mu46accessOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val source = attributes.get("@source") map { _.as[String]}
  lazy val rules = attributes.get("@rules") map { _.as[String]}
  lazy val identifier = attributes.get("@identifier") map { _.as[String]}
  lazy val normal = attributes.get("@normal") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val relator = attributes.get("@relator") map { _.as[String]}
}

      


case class Occupation(part: Seq[Part] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46accessOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val source = attributes.get("@source") map { _.as[String]}
  lazy val rules = attributes.get("@rules") map { _.as[String]}
  lazy val identifier = attributes.get("@identifier") map { _.as[String]}
  lazy val normal = attributes.get("@normal") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val relator = attributes.get("@relator") map { _.as[String]}
}

      


case class Persname(part: Seq[Part] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends OriginationOption with RepositoryOption with Mu46accessOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val source = attributes.get("@source") map { _.as[String]}
  lazy val rules = attributes.get("@rules") map { _.as[String]}
  lazy val identifier = attributes.get("@identifier") map { _.as[String]}
  lazy val normal = attributes.get("@normal") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val relator = attributes.get("@relator") map { _.as[String]}
}

      


case class Subject(part: Seq[Part] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46accessOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val source = attributes.get("@source") map { _.as[String]}
  lazy val rules = attributes.get("@rules") map { _.as[String]}
  lazy val identifier = attributes.get("@identifier") map { _.as[String]}
  lazy val normal = attributes.get("@normal") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val relator = attributes.get("@relator") map { _.as[String]}
}

      

sealed trait RenderType

object RenderType {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[RenderType]): RenderType = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: RenderType) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[RenderType] = Seq(AltrenderValue, BoldValue, BolddoublequoteValue, BolditalicValue, BoldsinglequoteValue, BoldsmcapsValue, BoldunderlineValue, DoublequoteValue, ItalicValue, NonproportValue, SinglequoteValue, SmcapsValue, SubValue, SuperValue, UnderlineValue)
}

case object AltrenderValue extends RenderType { override def toString = "altrender" }
case object BoldValue extends RenderType { override def toString = "bold" }
case object BolddoublequoteValue extends RenderType { override def toString = "bolddoublequote" }
case object BolditalicValue extends RenderType { override def toString = "bolditalic" }
case object BoldsinglequoteValue extends RenderType { override def toString = "boldsinglequote" }
case object BoldsmcapsValue extends RenderType { override def toString = "boldsmcaps" }
case object BoldunderlineValue extends RenderType { override def toString = "boldunderline" }
case object DoublequoteValue extends RenderType { override def toString = "doublequote" }
case object ItalicValue extends RenderType { override def toString = "italic" }
case object NonproportValue extends RenderType { override def toString = "nonproport" }
case object SinglequoteValue extends RenderType { override def toString = "singlequote" }
case object SmcapsValue extends RenderType { override def toString = "smcaps" }
case object SubValue extends RenderType { override def toString = "sub" }
case object SuperValue extends RenderType { override def toString = "super" }
case object UnderlineValue extends RenderType { override def toString = "underline" }


case class Title(part: Seq[Part] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46accessOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val source = attributes.get("@source") map { _.as[String]}
  lazy val rules = attributes.get("@rules") map { _.as[String]}
  lazy val identifier = attributes.get("@identifier") map { _.as[String]}
  lazy val normal = attributes.get("@normal") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val relator = attributes.get("@relator") map { _.as[String]}
  lazy val render = attributes.get("@render") map { _.as[RenderType]}
}

      


case class Part(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicu46datable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val source = attributes.get("@source") map { _.as[String]}
  lazy val rules = attributes.get("@rules") map { _.as[String]}
  lazy val identifier = attributes.get("@identifier") map { _.as[String]}
}

      


case class P(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46parau46contentable with EditionstmtOption with PublicationstmtOption with SeriesstmtOption with BlockquoteOption with Mu46blocksOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
}

      


case class Blockquote(blockquoteoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46interOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
}

      

trait BlockquoteOption

case class Chronlist(head: Option[Head] = None,
  listhead: Option[Listhead] = None,
  chronitem: Seq[Chronitem] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46interu46noquoteOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Chronitem(chronitemoption: scalaxb.DataRecord[ChronitemOption],
  chronitemoption2: Seq[scalaxb.DataRecord[ChronitemOption2]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      

case class ChronitemSequence1(geogname: Option[Geogname] = None,
  event: Event) extends ChronitemOption2

trait ChronitemOption2
trait ChronitemOption

case class Chronitemset(geogname: Seq[Geogname] = Nil,
  event: Seq[Event] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends ChronitemOption2 {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
}

      


case class Event(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46parau46contentable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      

sealed trait ListtypeType

object ListtypeType {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[ListtypeType]): ListtypeType = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: ListtypeType) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[ListtypeType] = Seq(Deflist, Unordered, Ordered)
}

case object Deflist extends ListtypeType { override def toString = "deflist" }
case object Unordered extends ListtypeType { override def toString = "unordered" }
case object Ordered extends ListtypeType { override def toString = "ordered" }

sealed trait Mark

object Mark {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Mark]): Mark = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Mark) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Mark] = Seq(Disc, Circle, Square, NoneType, Inherit)
}

case object Disc extends Mark { override def toString = "disc" }
case object Circle extends Mark { override def toString = "circle" }
case object Square extends Mark { override def toString = "square" }
case object NoneType extends Mark { override def toString = "none" }
case object Inherit extends Mark { override def toString = "inherit" }

sealed trait Numeration

object Numeration {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Numeration]): Numeration = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Numeration) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Numeration] = Seq(Decimal, Decimalu45leadingu45zero, Loweru45roman, Upperu45roman, Loweru45greek, Loweru45latin, Upperu45latin, Armenian, Georgian, Loweru45alpha, Upperu45alpha, InheritValue)
}

case object Decimal extends Numeration { override def toString = "decimal" }
case object Decimalu45leadingu45zero extends Numeration { override def toString = "decimal-leading-zero" }
case object Loweru45roman extends Numeration { override def toString = "lower-roman" }
case object Upperu45roman extends Numeration { override def toString = "upper-roman" }
case object Loweru45greek extends Numeration { override def toString = "lower-greek" }
case object Loweru45latin extends Numeration { override def toString = "lower-latin" }
case object Upperu45latin extends Numeration { override def toString = "upper-latin" }
case object Armenian extends Numeration { override def toString = "armenian" }
case object Georgian extends Numeration { override def toString = "georgian" }
case object Loweru45alpha extends Numeration { override def toString = "lower-alpha" }
case object Upperu45alpha extends Numeration { override def toString = "upper-alpha" }
case object InheritValue extends Numeration { override def toString = "inherit" }


case class ListType(head: Option[Head] = None,
  listtypeoption: Seq[scalaxb.DataRecord[ListTypeOption]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46interu46noquoteOption with Mu46parau46contentableOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val listtype = attributes.get("@listtype") map { _.as[ListtypeType]}
  lazy val mark = attributes.get("@mark") map { _.as[Mark]}
  lazy val numeration = attributes.get("@numeration") map { _.as[Numeration]}
}

      

trait ListTypeOption
case class ListTypeSequence1(listhead: Option[Listhead] = None,
  defitem: Seq[Defitem] = Nil) extends ListTypeOption


case class Defitem(label: Label,
  item: Item,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
}

      


case class Label(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
}

      


case class Item(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46parau46contentable with ListTypeOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
}

      


case class Listhead(head01: Option[Head01] = None,
  head02: Option[Head02] = None,
  head03: Option[Head03] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
}

      


case class Head01(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
}

      


case class Head02(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
}

      


case class Head03(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
}

      

sealed trait Frame

object Frame {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Frame]): Frame = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Frame) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Frame] = Seq(Top, Bottom, Topbot, AllType, Sides, NoneTypeValue)
}

case object Top extends Frame { override def toString = "top" }
case object Bottom extends Frame { override def toString = "bottom" }
case object Topbot extends Frame { override def toString = "topbot" }
case object AllType extends Frame { override def toString = "all" }
case object Sides extends Frame { override def toString = "sides" }
case object NoneTypeValue extends Frame { override def toString = "none" }


case class Table(head: Option[Head] = None,
  tgroup: Seq[Tgroup] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46interu46noquoteOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val frame = attributes.get("@frame") map { _.as[Frame]}
  lazy val colsep = attributes.get("@colsep") map { _.as[Avu46boolean]}
  lazy val rowsep = attributes.get("@rowsep") map { _.as[Avu46boolean]}
  lazy val pgwide = attributes.get("@pgwide") map { _.as[Avu46boolean]}
}

      

sealed trait Align

object Align {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Align]): Align = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Align) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Align] = Seq(LeftType, RightType, Center, Justify, CharType)
}

case object LeftType extends Align { override def toString = "left" }
case object RightType extends Align { override def toString = "right" }
case object Center extends Align { override def toString = "center" }
case object Justify extends Align { override def toString = "justify" }
case object CharType extends Align { override def toString = "char" }


case class Tgroup(colspec: Seq[Colspec] = Nil,
  thead: Option[Thead] = None,
  tbody: Tbody,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val cols = attributes("@cols").as[String]
  lazy val colsep = attributes.get("@colsep") map { _.as[Avu46boolean]}
  lazy val rowsep = attributes.get("@rowsep") map { _.as[Avu46boolean]}
  lazy val align = attributes.get("@align") map { _.as[Align]}
}

      

sealed trait AlignType

object AlignType {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[AlignType]): AlignType = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: AlignType) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[AlignType] = Seq(LeftTypeValue, RightTypeValue, CenterValue, JustifyValue, CharTypeValue)
}

case object LeftTypeValue extends AlignType { override def toString = "left" }
case object RightTypeValue extends AlignType { override def toString = "right" }
case object CenterValue extends AlignType { override def toString = "center" }
case object JustifyValue extends AlignType { override def toString = "justify" }
case object CharTypeValue extends AlignType { override def toString = "char" }


case class Colspec(attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val colnum = attributes.get("@colnum") map { _.as[String]}
  lazy val colname = attributes.get("@colname") map { _.as[String]}
  lazy val colwidth = attributes.get("@colwidth") map { _.as[String]}
  lazy val colsep = attributes.get("@colsep") map { _.as[Avu46boolean]}
  lazy val rowsep = attributes.get("@rowsep") map { _.as[Avu46boolean]}
  lazy val align = attributes.get("@align") map { _.as[AlignType]}
  lazy val char = attributes.get("@char") map { _.as[String]}
  lazy val charoff = attributes.get("@charoff") map { _.as[String]}
}

      

sealed trait Valign

object Valign {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Valign]): Valign = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Valign) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Valign] = Seq(TopValue, Middle, BottomValue)
}

case object TopValue extends Valign { override def toString = "top" }
case object Middle extends Valign { override def toString = "middle" }
case object BottomValue extends Valign { override def toString = "bottom" }


case class Tbody(row: Seq[Row] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val valign = attributes.get("@valign") map { _.as[Valign]}
}

      

sealed trait ValignType

object ValignType {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[ValignType]): ValignType = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: ValignType) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[ValignType] = Seq(TopValue2, MiddleValue, BottomValue2)
}

case object TopValue2 extends ValignType { override def toString = "top" }
case object MiddleValue extends ValignType { override def toString = "middle" }
case object BottomValue2 extends ValignType { override def toString = "bottom" }


case class Row(entry: Seq[Entry] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val rowsep = attributes.get("@rowsep") map { _.as[Avu46boolean]}
  lazy val valign = attributes.get("@valign") map { _.as[ValignType]}
}

      

sealed trait AlignType2

object AlignType2 {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[AlignType2]): AlignType2 = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: AlignType2) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[AlignType2] = Seq(LeftTypeValue2, RightTypeValue2, CenterValue2, JustifyValue2, CharTypeValue2)
}

case object LeftTypeValue2 extends AlignType2 { override def toString = "left" }
case object RightTypeValue2 extends AlignType2 { override def toString = "right" }
case object CenterValue2 extends AlignType2 { override def toString = "center" }
case object JustifyValue2 extends AlignType2 { override def toString = "justify" }
case object CharTypeValue2 extends AlignType2 { override def toString = "char" }

sealed trait ValignType2

object ValignType2 {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[ValignType2]): ValignType2 = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: ValignType2) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[ValignType2] = Seq(TopValue3, MiddleValue2, BottomValue3)
}

case object TopValue3 extends ValignType2 { override def toString = "top" }
case object MiddleValue2 extends ValignType2 { override def toString = "middle" }
case object BottomValue3 extends ValignType2 { override def toString = "bottom" }


case class Entry(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46parau46contentable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val colname = attributes.get("@colname") map { _.as[String]}
  lazy val namest = attributes.get("@namest") map { _.as[String]}
  lazy val nameend = attributes.get("@nameend") map { _.as[String]}
  lazy val morerows = attributes.get("@morerows") map { _.as[String]}
  lazy val colsep = attributes.get("@colsep") map { _.as[Avu46boolean]}
  lazy val rowsep = attributes.get("@rowsep") map { _.as[Avu46boolean]}
  lazy val align = attributes.get("@align") map { _.as[AlignType2]}
  lazy val char = attributes.get("@char") map { _.as[String]}
  lazy val charoff = attributes.get("@charoff") map { _.as[String]}
  lazy val valign = attributes.get("@valign") map { _.as[ValignType2]}
}

      

sealed trait ValignType3

object ValignType3 {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[ValignType3]): ValignType3 = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: ValignType3) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[ValignType3] = Seq(TopValue4, MiddleValue3, BottomValue4)
}

case object TopValue4 extends ValignType3 { override def toString = "top" }
case object MiddleValue3 extends ValignType3 { override def toString = "middle" }
case object BottomValue4 extends ValignType3 { override def toString = "bottom" }


case class Thead(row: Seq[Row] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val valign = attributes.get("@valign") map { _.as[ValignType3]}
}

      


case class Language(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends LangmaterialOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val label = attributes.get("@label") map { _.as[String]}
  lazy val langcode = attributes.get("@langcode") map { _.as[String]}
}

      


case class Languageset(language: Seq[Language] = Nil,
  scriptElement: Seq[Script] = Nil,
  descriptivenote: Option[Descriptivenote] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends LangmaterialOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Script(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val label = attributes.get("@label") map { _.as[String]}
  lazy val scriptcode = attributes.get("@scriptcode") map { _.as[String]}
}

      


case class Dimensions(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends PhysdescstructuredOption with DimensionsOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val unit = attributes.get("@unit") map { _.as[String]}
}

      

trait DimensionsOption

case class Physfacet(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicu46plusu46accessable with PhysdescstructuredOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val source = attributes.get("@source") map { _.as[String]}
  lazy val rules = attributes.get("@rules") map { _.as[String]}
  lazy val identifier = attributes.get("@identifier") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      


case class Address(addressline: Seq[Addressline] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends PublicationstmtOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
}

      


case class Addressline(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      


case class Archref(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicu46plusu46accessable with BibliographyOption with OtherfindaidOption with RelatedmaterialOption with SeparatedmaterialOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Bibref(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicu46plusu46accessable with BibliographyOption with OtherfindaidOption with RelatedmaterialOption with SeparatedmaterialOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


case class Descriptivenote(p: Seq[P] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

sealed trait Show

object Show {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Show]): Show = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Show) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Show] = Seq(NewValue, Replace, Embed, Other, NoneTypeValue2)
}

case object NewValue extends Show { override def toString = "new" }
case object Replace extends Show { override def toString = "replace" }
case object Embed extends Show { override def toString = "embed" }
case object Other extends Show { override def toString = "other" }
case object NoneTypeValue2 extends Show { override def toString = "none" }

sealed trait Actuate

object Actuate {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Actuate]): Actuate = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Actuate) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Actuate] = Seq(Onload, Onrequest, OtherValue, NoneTypeValue3)
}

case object Onload extends Actuate { override def toString = "onload" }
case object Onrequest extends Actuate { override def toString = "onrequest" }
case object OtherValue extends Actuate { override def toString = "other" }
case object NoneTypeValue3 extends Actuate { override def toString = "none" }


case class Footnote(mu46blocksOption1: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends RefOption with Mu46mixedu46basicu46plusu46elementsOption with Mu46mixedu46basicu46plusu46accessableOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val show = attributes.get("@show") map { _.as[Show]}
  lazy val actuate = attributes.get("@actuate") map { _.as[Actuate]}
}

      


case class Head(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val althead = attributes.get("@althead") map { _.as[String]}
}

      


case class Datesingle(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46datesinglable with LocalcontrolOption with UnitdatestructuredOption with ChronitemOption with DatesetOption with DatesetOption2 with RelationOption {
  lazy val standarddate = attributes.get("@standarddate") map { _.as[String]}
  lazy val notbefore = attributes.get("@notbefore") map { _.as[String]}
  lazy val notafter = attributes.get("@notafter") map { _.as[String]}
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      


case class Daterange(fromdate: Option[Fromdate] = None,
  todate: Option[Todate] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends LocalcontrolOption with UnitdatestructuredOption with ChronitemOption with DatesetOption with DatesetOption2 with RelationOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      


case class Fromdate(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46datesinglable {
  lazy val standarddate = attributes.get("@standarddate") map { _.as[String]}
  lazy val notbefore = attributes.get("@notbefore") map { _.as[String]}
  lazy val notafter = attributes.get("@notafter") map { _.as[String]}
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      


case class Todate(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46datesinglable {
  lazy val standarddate = attributes.get("@standarddate") map { _.as[String]}
  lazy val notbefore = attributes.get("@notbefore") map { _.as[String]}
  lazy val notafter = attributes.get("@notafter") map { _.as[String]}
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      


case class Dateset(datesetoption: scalaxb.DataRecord[DatesetOption],
  datesetoption2: Seq[scalaxb.DataRecord[DatesetOption2]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends UnitdatestructuredOption with ChronitemOption with RelationOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
}

      

trait DatesetOption
trait DatesetOption2

case class Abbr(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends RefOption with Mu46mixedu46basicu46elementsOption with Mu46mixedu46basicu46dateu46elementsOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val expan = attributes.get("@expan") map { _.as[String]}
}

      


case class Date(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable with PublicationstmtOption with RefOption with Mu46mixedu46basicu46dateu46elementsOption with Mu46mixedu46basicu46plusu46elementsOption with Mu46mixedu46basicu46plusu46accessableOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val era = attributes.get("@era") map { _.as[String]}
  lazy val calendar = attributes.get("@calendar") map { _.as[String]}
  lazy val normal = attributes.get("@normal") map { _.as[String]}
  lazy val certainty = attributes.get("@certainty") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

sealed trait RenderType2

object RenderType2 {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[RenderType2]): RenderType2 = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: RenderType2) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[RenderType2] = Seq(AltrenderValue2, BoldValue2, BolddoublequoteValue2, BolditalicValue2, BoldsinglequoteValue2, BoldsmcapsValue2, BoldunderlineValue2, DoublequoteValue2, ItalicValue2, NonproportValue2, SinglequoteValue2, SmcapsValue2, SubValue2, SuperValue2, UnderlineValue2)
}

case object AltrenderValue2 extends RenderType2 { override def toString = "altrender" }
case object BoldValue2 extends RenderType2 { override def toString = "bold" }
case object BolddoublequoteValue2 extends RenderType2 { override def toString = "bolddoublequote" }
case object BolditalicValue2 extends RenderType2 { override def toString = "bolditalic" }
case object BoldsinglequoteValue2 extends RenderType2 { override def toString = "boldsinglequote" }
case object BoldsmcapsValue2 extends RenderType2 { override def toString = "boldsmcaps" }
case object BoldunderlineValue2 extends RenderType2 { override def toString = "boldunderline" }
case object DoublequoteValue2 extends RenderType2 { override def toString = "doublequote" }
case object ItalicValue2 extends RenderType2 { override def toString = "italic" }
case object NonproportValue2 extends RenderType2 { override def toString = "nonproport" }
case object SinglequoteValue2 extends RenderType2 { override def toString = "singlequote" }
case object SmcapsValue2 extends RenderType2 { override def toString = "smcaps" }
case object SubValue2 extends RenderType2 { override def toString = "sub" }
case object SuperValue2 extends RenderType2 { override def toString = "super" }
case object UnderlineValue2 extends RenderType2 { override def toString = "underline" }


case class Emph(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable with RefOption with Mu46mixedu46basicu46elementsOption with Mu46mixedu46basicu46dateu46elementsOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val render = attributes.get("@render") map { _.as[RenderType2]}
}

      


case class Expan(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends RefOption with Mu46mixedu46basicu46elementsOption with Mu46mixedu46basicu46dateu46elementsOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val abbr = attributes.get("@abbr") map { _.as[String]}
}

      

sealed trait RenderType3

object RenderType3 {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[RenderType3]): RenderType3 = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: RenderType3) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[RenderType3] = Seq(AltrenderValue3, BoldValue3, BolddoublequoteValue3, BolditalicValue3, BoldsinglequoteValue3, BoldsmcapsValue3, BoldunderlineValue3, DoublequoteValue3, ItalicValue3, NonproportValue3, SinglequoteValue3, SmcapsValue3, SubValue3, SuperValue3, UnderlineValue3)
}

case object AltrenderValue3 extends RenderType3 { override def toString = "altrender" }
case object BoldValue3 extends RenderType3 { override def toString = "bold" }
case object BolddoublequoteValue3 extends RenderType3 { override def toString = "bolddoublequote" }
case object BolditalicValue3 extends RenderType3 { override def toString = "bolditalic" }
case object BoldsinglequoteValue3 extends RenderType3 { override def toString = "boldsinglequote" }
case object BoldsmcapsValue3 extends RenderType3 { override def toString = "boldsmcaps" }
case object BoldunderlineValue3 extends RenderType3 { override def toString = "boldunderline" }
case object DoublequoteValue3 extends RenderType3 { override def toString = "doublequote" }
case object ItalicValue3 extends RenderType3 { override def toString = "italic" }
case object NonproportValue3 extends RenderType3 { override def toString = "nonproport" }
case object SinglequoteValue3 extends RenderType3 { override def toString = "singlequote" }
case object SmcapsValue3 extends RenderType3 { override def toString = "smcaps" }
case object SubValue3 extends RenderType3 { override def toString = "sub" }
case object SuperValue3 extends RenderType3 { override def toString = "super" }
case object UnderlineValue3 extends RenderType3 { override def toString = "underline" }


case class Foreign(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicu46elementsOption with Mu46mixedu46basicu46dateu46elementsOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val render = attributes.get("@render") map { _.as[RenderType3]}
}

      


case class Lb() extends RefOption with Mu46mixedu46basicu46elementsOption with Mu46mixedu46basicu46dateu46elementsOption
      


case class Num(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable with PublicationstmtOption with SeriesstmtOption with RefOption with Mu46mixedu46basicu46plusu46elementsOption with Mu46mixedu46basicu46plusu46accessableOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

sealed trait RenderType4

object RenderType4 {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[RenderType4]): RenderType4 = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: RenderType4) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[RenderType4] = Seq(AltrenderValue4, BoldValue4, BolddoublequoteValue4, BolditalicValue4, BoldsinglequoteValue4, BoldsmcapsValue4, BoldunderlineValue4, DoublequoteValue4, ItalicValue4, NonproportValue4, SinglequoteValue4, SmcapsValue4, SubValue4, SuperValue4, UnderlineValue4)
}

case object AltrenderValue4 extends RenderType4 { override def toString = "altrender" }
case object BoldValue4 extends RenderType4 { override def toString = "bold" }
case object BolddoublequoteValue4 extends RenderType4 { override def toString = "bolddoublequote" }
case object BolditalicValue4 extends RenderType4 { override def toString = "bolditalic" }
case object BoldsinglequoteValue4 extends RenderType4 { override def toString = "boldsinglequote" }
case object BoldsmcapsValue4 extends RenderType4 { override def toString = "boldsmcaps" }
case object BoldunderlineValue4 extends RenderType4 { override def toString = "boldunderline" }
case object DoublequoteValue4 extends RenderType4 { override def toString = "doublequote" }
case object ItalicValue4 extends RenderType4 { override def toString = "italic" }
case object NonproportValue4 extends RenderType4 { override def toString = "nonproport" }
case object SinglequoteValue4 extends RenderType4 { override def toString = "singlequote" }
case object SmcapsValue4 extends RenderType4 { override def toString = "smcaps" }
case object SubValue4 extends RenderType4 { override def toString = "sub" }
case object SuperValue4 extends RenderType4 { override def toString = "super" }
case object UnderlineValue4 extends RenderType4 { override def toString = "underline" }


case class Quote(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46mixedu46basicable with RefOption with Mu46mixedu46basicu46plusu46elementsOption with Mu46mixedu46basicu46plusu46accessableOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val render = attributes.get("@render") map { _.as[RenderType4]}
}

      


case class Ptr(attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends RefOption with Mu46refsOption with Mu46mixedu46basicu46elementsOption with Mu46mixedu46basicu46dateu46elementsOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val target = attributes.get("@target") map { _.as[String]}
  lazy val xpointer = attributes.get("@xpointer") map { _.as[String]}
  lazy val href = attributes.get("@href") map { _.as[String]}
  lazy val linkrole = attributes.get("@linkrole") map { _.as[java.net.URI]}
  lazy val arcrole = attributes.get("@arcrole") map { _.as[java.net.URI]}
  lazy val linktitle = attributes.get("@linktitle") map { _.as[String]}
  lazy val show = attributes.get("@show") map { _.as[ShowType]}
  lazy val actuate = attributes.get("@actuate") map { _.as[ActuateType]}
  lazy val entityref = attributes.get("@entityref") map { _.as[String]}
}

      


case class Ref(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46refsOption with Mu46mixedu46basicu46elementsOption with Mu46mixedu46basicu46dateu46elementsOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val target = attributes.get("@target") map { _.as[String]}
  lazy val xpointer = attributes.get("@xpointer") map { _.as[String]}
  lazy val href = attributes.get("@href") map { _.as[String]}
  lazy val linkrole = attributes.get("@linkrole") map { _.as[java.net.URI]}
  lazy val arcrole = attributes.get("@arcrole") map { _.as[java.net.URI]}
  lazy val linktitle = attributes.get("@linktitle") map { _.as[String]}
  lazy val show = attributes.get("@show") map { _.as[ShowType]}
  lazy val actuate = attributes.get("@actuate") map { _.as[ActuateType]}
  lazy val entityref = attributes.get("@entityref") map { _.as[String]}
}

      

trait RefOption
sealed trait Dsctype

object Dsctype {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Dsctype]): Dsctype = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Dsctype) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Dsctype] = Seq(Analyticover, Combined, Inu45depth, Otherdsctype)
}

case object Analyticover extends Dsctype { override def toString = "analyticover" }
case object Combined extends Dsctype { override def toString = "combined" }
case object Inu45depth extends Dsctype { override def toString = "in-depth" }
case object Otherdsctype extends Dsctype { override def toString = "otherdsctype" }


case class Dsc(dscsequence1: DscSequence1,
  thead: Option[Thead] = None,
  mu46cOrC01Option3: Seq[scalaxb.DataRecord[Mu46cOrC01Option]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends ArchdescOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val dsctype = attributes.get("@dsctype") map { _.as[Dsctype]}
  lazy val otherdsctype = attributes.get("@otherdsctype") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

case class DscSequence1(head: Option[Head] = None,
  mu46blocksOption2: Seq[scalaxb.DataRecord[Any]] = Nil)


case class C(head: Option[Head] = None,
  did: Did,
  mu46descu46baseOption3: Seq[scalaxb.DataRecord[Mu46descu46baseOption]] = Nil,
  csequence1: Seq[CSequence1] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46cu46basable with Mu46cOrC01Option {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val base = attributes.get("@base") map { _.as[java.net.URI]}
  lazy val level = attributes.get("@level") map { _.as[Level]}
  lazy val otherlevel = attributes.get("@otherlevel") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

case class CSequence1(thead: Option[Thead] = None,
  c: Seq[C] = Nil)


case class C01(head: Option[Head] = None,
  did: Did,
  mu46descu46baseOption3: Seq[scalaxb.DataRecord[Mu46descu46baseOption]] = Nil,
  c01sequence1: Seq[C01Sequence1] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46cu46basable with Mu46cOrC01Option {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val base = attributes.get("@base") map { _.as[java.net.URI]}
  lazy val level = attributes.get("@level") map { _.as[Level]}
  lazy val otherlevel = attributes.get("@otherlevel") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

case class C01Sequence1(thead: Option[Thead] = None,
  c02: Seq[C02] = Nil)


case class C02(head: Option[Head] = None,
  did: Did,
  mu46descu46baseOption3: Seq[scalaxb.DataRecord[Mu46descu46baseOption]] = Nil,
  c02sequence1: Seq[C02Sequence1] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46cu46basable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val base = attributes.get("@base") map { _.as[java.net.URI]}
  lazy val level = attributes.get("@level") map { _.as[Level]}
  lazy val otherlevel = attributes.get("@otherlevel") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

case class C02Sequence1(thead: Option[Thead] = None,
  c03: Seq[C03] = Nil)


case class C03(head: Option[Head] = None,
  did: Did,
  mu46descu46baseOption3: Seq[scalaxb.DataRecord[Mu46descu46baseOption]] = Nil,
  c03sequence1: Seq[C03Sequence1] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46cu46basable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val base = attributes.get("@base") map { _.as[java.net.URI]}
  lazy val level = attributes.get("@level") map { _.as[Level]}
  lazy val otherlevel = attributes.get("@otherlevel") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

case class C03Sequence1(thead: Option[Thead] = None,
  c04: Seq[C04] = Nil)


case class C04(head: Option[Head] = None,
  did: Did,
  mu46descu46baseOption3: Seq[scalaxb.DataRecord[Mu46descu46baseOption]] = Nil,
  c04sequence1: Seq[C04Sequence1] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46cu46basable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val base = attributes.get("@base") map { _.as[java.net.URI]}
  lazy val level = attributes.get("@level") map { _.as[Level]}
  lazy val otherlevel = attributes.get("@otherlevel") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

case class C04Sequence1(thead: Option[Thead] = None,
  c05: Seq[C05] = Nil)


case class C05(head: Option[Head] = None,
  did: Did,
  mu46descu46baseOption3: Seq[scalaxb.DataRecord[Mu46descu46baseOption]] = Nil,
  c05sequence1: Seq[C05Sequence1] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46cu46basable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val base = attributes.get("@base") map { _.as[java.net.URI]}
  lazy val level = attributes.get("@level") map { _.as[Level]}
  lazy val otherlevel = attributes.get("@otherlevel") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

case class C05Sequence1(thead: Option[Thead] = None,
  c06: Seq[C06] = Nil)


case class C06(head: Option[Head] = None,
  did: Did,
  mu46descu46baseOption3: Seq[scalaxb.DataRecord[Mu46descu46baseOption]] = Nil,
  c06sequence1: Seq[C06Sequence1] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46cu46basable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val base = attributes.get("@base") map { _.as[java.net.URI]}
  lazy val level = attributes.get("@level") map { _.as[Level]}
  lazy val otherlevel = attributes.get("@otherlevel") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

case class C06Sequence1(thead: Option[Thead] = None,
  c07: Seq[C07] = Nil)


case class C07(head: Option[Head] = None,
  did: Did,
  mu46descu46baseOption3: Seq[scalaxb.DataRecord[Mu46descu46baseOption]] = Nil,
  c07sequence1: Seq[C07Sequence1] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46cu46basable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val base = attributes.get("@base") map { _.as[java.net.URI]}
  lazy val level = attributes.get("@level") map { _.as[Level]}
  lazy val otherlevel = attributes.get("@otherlevel") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

case class C07Sequence1(thead: Option[Thead] = None,
  c08: Seq[C08] = Nil)


case class C08(head: Option[Head] = None,
  did: Did,
  mu46descu46baseOption3: Seq[scalaxb.DataRecord[Mu46descu46baseOption]] = Nil,
  c08sequence1: Seq[C08Sequence1] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46cu46basable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val base = attributes.get("@base") map { _.as[java.net.URI]}
  lazy val level = attributes.get("@level") map { _.as[Level]}
  lazy val otherlevel = attributes.get("@otherlevel") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

case class C08Sequence1(thead: Option[Thead] = None,
  c09: Seq[C09] = Nil)


case class C09(head: Option[Head] = None,
  did: Did,
  mu46descu46baseOption3: Seq[scalaxb.DataRecord[Mu46descu46baseOption]] = Nil,
  c09sequence1: Seq[C09Sequence1] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46cu46basable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val base = attributes.get("@base") map { _.as[java.net.URI]}
  lazy val level = attributes.get("@level") map { _.as[Level]}
  lazy val otherlevel = attributes.get("@otherlevel") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

case class C09Sequence1(thead: Option[Thead] = None,
  c10: Seq[C10] = Nil)


case class C10(head: Option[Head] = None,
  did: Did,
  mu46descu46baseOption3: Seq[scalaxb.DataRecord[Mu46descu46baseOption]] = Nil,
  c10sequence1: Seq[C10Sequence1] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46cu46basable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val base = attributes.get("@base") map { _.as[java.net.URI]}
  lazy val level = attributes.get("@level") map { _.as[Level]}
  lazy val otherlevel = attributes.get("@otherlevel") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

case class C10Sequence1(thead: Option[Thead] = None,
  c11: Seq[C11] = Nil)


case class C11(head: Option[Head] = None,
  did: Did,
  mu46descu46baseOption3: Seq[scalaxb.DataRecord[Mu46descu46baseOption]] = Nil,
  c11sequence1: Seq[C11Sequence1] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46cu46basable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val base = attributes.get("@base") map { _.as[java.net.URI]}
  lazy val level = attributes.get("@level") map { _.as[Level]}
  lazy val otherlevel = attributes.get("@otherlevel") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      

case class C11Sequence1(thead: Option[Thead] = None,
  c12: Seq[C12] = Nil)


case class C12()
      


case class Relations(relation: Seq[Relation] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46descu46baseOption {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val base = attributes.get("@base") map { _.as[java.net.URI]}
}

      

sealed trait Relationtype

object Relationtype {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Relationtype]): Relationtype = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Relationtype) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Relationtype] = Seq(Cpfrelation, Resourcerelation, Functionrelation, Otherrelationtype)
}

case object Cpfrelation extends Relationtype { override def toString = "cpfrelation" }
case object Resourcerelation extends Relationtype { override def toString = "resourcerelation" }
case object Functionrelation extends Relationtype { override def toString = "functionrelation" }
case object Otherrelationtype extends Relationtype { override def toString = "otherrelationtype" }


case class Relation(relationentry: Seq[Relationentry] = Nil,
  objectxmlwrap: Option[Objectxmlwrap] = None,
  relationoption: Option[scalaxb.DataRecord[RelationOption]] = None,
  geogname: Option[Geogname] = None,
  descriptivenote: Option[Descriptivenote] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val relationtype = attributes("@relationtype").as[Relationtype]
  lazy val otherrelationtype = attributes.get("@otherrelationtype") map { _.as[String]}
  lazy val lastdatetimeverified = attributes.get("@lastdatetimeverified") map { _.as[String]}
  lazy val href = attributes.get("@href") map { _.as[String]}
  lazy val linkrole = attributes.get("@linkrole") map { _.as[java.net.URI]}
  lazy val arcrole = attributes.get("@arcrole") map { _.as[java.net.URI]}
  lazy val linktitle = attributes.get("@linktitle") map { _.as[String]}
  lazy val show = attributes.get("@show") map { _.as[ShowType]}
  lazy val actuate = attributes.get("@actuate") map { _.as[ActuateType]}
}

      

trait RelationOption

case class Relationentry(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
  lazy val localtype = attributes.get("@localtype") map { _.as[String]}
  lazy val transliteration = attributes.get("@transliteration") map { _.as[String]}
}

      


case class Objectxmlwrap(any: scalaxb.DataRecord[Any],
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Eu46anynamable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
}

      


trait Eu46anynamable {
  def any: scalaxb.DataRecord[Any]
}


case class Eu46anyname(any: scalaxb.DataRecord[Any]) extends Eu46anynamable
      


trait Mu46cu46basable {
  def head: Option[Head]
  def did: Did
  def mu46descu46baseOption3: Seq[scalaxb.DataRecord[Mu46descu46baseOption]]
  def id: Option[String]
  def altrender: Option[String]
  def audience: Option[Audience]
  def lang: Option[String]
  def script: Option[String]
  def base: Option[java.net.URI]
  def level: Option[Level]
  def otherlevel: Option[String]
  def encodinganalog: Option[String]
}


case class Mu46cu46base(head: Option[Head] = None,
  did: Did,
  mu46descu46baseOption3: Seq[scalaxb.DataRecord[Mu46descu46baseOption]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46cu46basable {
  lazy val id = attributes.get("@id") map { _.as[String]}
  lazy val altrender = attributes.get("@altrender") map { _.as[String]}
  lazy val audience = attributes.get("@audience") map { _.as[Audience]}
  lazy val lang = attributes.get("@lang") map { _.as[String]}
  lazy val script = attributes.get("@script") map { _.as[String]}
  lazy val base = attributes.get("@base") map { _.as[java.net.URI]}
  lazy val level = attributes.get("@level") map { _.as[Level]}
  lazy val otherlevel = attributes.get("@otherlevel") map { _.as[String]}
  lazy val encodinganalog = attributes.get("@encodinganalog") map { _.as[String]}
}

      


trait Mu46datesinglable extends Mu46mixedu46basicable {
  def standarddate: Option[String]
  def notbefore: Option[String]
  def notafter: Option[String]
}


case class Mu46datesingle(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends Mu46datesinglable {
  lazy val standarddate = attributes.get("@standarddate") map { _.as[String]}
  lazy val notbefore = attributes.get("@notbefore") map { _.as[String]}
  lazy val notafter = attributes.get("@notafter") map { _.as[String]}
}

      


trait Mu46mixedu46basicable {
  
}


case class Mu46mixedu46basic(mixed: Seq[scalaxb.DataRecord[Any]] = Nil) extends Mu46mixedu46basicable
      


trait Mu46mixedu46basicu46datable {
  
}


case class Mu46mixedu46basicu46date(mixed: Seq[scalaxb.DataRecord[Any]] = Nil) extends Mu46mixedu46basicu46datable
      


trait Mu46mixedu46basicu46plusu46accessable {
  
}


case class Mu46mixedu46basicu46plusu46access(mixed: Seq[scalaxb.DataRecord[Any]] = Nil) extends Mu46mixedu46basicu46plusu46accessable
      

trait Mu46mixedu46basicu46plusu46accessableOption

trait Mu46parau46contentable {
  
}


case class Mu46parau46content(mixed: Seq[scalaxb.DataRecord[Any]] = Nil) extends Mu46parau46contentable
      

trait Mu46parau46contentableOption
sealed trait ShowType

object ShowType {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[ShowType]): ShowType = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: ShowType) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[ShowType] = Seq(NewValue2, ReplaceValue, EmbedValue, OtherValue2, NoneTypeValue4)
}

case object NewValue2 extends ShowType { override def toString = "new" }
case object ReplaceValue extends ShowType { override def toString = "replace" }
case object EmbedValue extends ShowType { override def toString = "embed" }
case object OtherValue2 extends ShowType { override def toString = "other" }
case object NoneTypeValue4 extends ShowType { override def toString = "none" }

sealed trait ActuateType

object ActuateType {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[ActuateType]): ActuateType = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: ActuateType) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[ActuateType] = Seq(OnloadValue, OnrequestValue, OtherValue3, NoneTypeValue5)
}

case object OnloadValue extends ActuateType { override def toString = "onload" }
case object OnrequestValue extends ActuateType { override def toString = "onrequest" }
case object OtherValue3 extends ActuateType { override def toString = "other" }
case object NoneTypeValue5 extends ActuateType { override def toString = "none" }

sealed trait Audience

object Audience {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Audience]): Audience = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Audience) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Audience] = Seq(External, Internal)
}

case object External extends Audience { override def toString = "external" }
case object Internal extends Audience { override def toString = "internal" }

sealed trait Level

object Level {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Level]): Level = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Level) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Level] = Seq(Class, Collection, File, Fonds, ItemValue, Otherlevel, Recordgrp, Series, Subfonds, Subgrp, Subseries)
}

case object Class extends Level { override def toString = "class" }
case object Collection extends Level { override def toString = "collection" }
case object File extends Level { override def toString = "file" }
case object Fonds extends Level { override def toString = "fonds" }
case object ItemValue extends Level { override def toString = "item" }
case object Otherlevel extends Level { override def toString = "otherlevel" }
case object Recordgrp extends Level { override def toString = "recordgrp" }
case object Series extends Level { override def toString = "series" }
case object Subfonds extends Level { override def toString = "subfonds" }
case object Subgrp extends Level { override def toString = "subgrp" }
case object Subseries extends Level { override def toString = "subseries" }

sealed trait ActuateType2

object ActuateType2 {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[ActuateType2]): ActuateType2 = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: ActuateType2) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[ActuateType2] = Seq(OnloadValue2, OnrequestValue2, OtherValue4, NoneTypeValue6)
}

case object OnloadValue2 extends ActuateType2 { override def toString = "onload" }
case object OnrequestValue2 extends ActuateType2 { override def toString = "onrequest" }
case object OtherValue4 extends ActuateType2 { override def toString = "other" }
case object NoneTypeValue6 extends ActuateType2 { override def toString = "none" }

sealed trait ShowType2

object ShowType2 {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[ShowType2]): ShowType2 = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: ShowType2) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[ShowType2] = Seq(NewValue3, ReplaceValue2, EmbedValue2, OtherValue5, NoneTypeValue7)
}

case object NewValue3 extends ShowType2 { override def toString = "new" }
case object ReplaceValue2 extends ShowType2 { override def toString = "replace" }
case object EmbedValue2 extends ShowType2 { override def toString = "embed" }
case object OtherValue5 extends ShowType2 { override def toString = "other" }
case object NoneTypeValue7 extends ShowType2 { override def toString = "none" }

sealed trait AlignType3

object AlignType3 {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[AlignType3]): AlignType3 = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: AlignType3) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[AlignType3] = Seq(LeftTypeValue3, RightTypeValue3, CenterValue3, JustifyValue3, CharTypeValue3)
}

case object LeftTypeValue3 extends AlignType3 { override def toString = "left" }
case object RightTypeValue3 extends AlignType3 { override def toString = "right" }
case object CenterValue3 extends AlignType3 { override def toString = "center" }
case object JustifyValue3 extends AlignType3 { override def toString = "justify" }
case object CharTypeValue3 extends AlignType3 { override def toString = "char" }

sealed trait ValignType4

object ValignType4 {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[ValignType4]): ValignType4 = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: ValignType4) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[ValignType4] = Seq(TopValue5, MiddleValue4, BottomValue5)
}

case object TopValue5 extends ValignType4 { override def toString = "top" }
case object MiddleValue4 extends ValignType4 { override def toString = "middle" }
case object BottomValue5 extends ValignType4 { override def toString = "bottom" }

sealed trait RenderType5

object RenderType5 {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[RenderType5]): RenderType5 = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: RenderType5) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[RenderType5] = Seq(AltrenderValue5, BoldValue5, BolddoublequoteValue5, BolditalicValue5, BoldsinglequoteValue5, BoldsmcapsValue5, BoldunderlineValue5, DoublequoteValue5, ItalicValue5, NonproportValue5, SinglequoteValue5, SmcapsValue5, SubValue5, SuperValue5, UnderlineValue5)
}

case object AltrenderValue5 extends RenderType5 { override def toString = "altrender" }
case object BoldValue5 extends RenderType5 { override def toString = "bold" }
case object BolddoublequoteValue5 extends RenderType5 { override def toString = "bolddoublequote" }
case object BolditalicValue5 extends RenderType5 { override def toString = "bolditalic" }
case object BoldsinglequoteValue5 extends RenderType5 { override def toString = "boldsinglequote" }
case object BoldsmcapsValue5 extends RenderType5 { override def toString = "boldsmcaps" }
case object BoldunderlineValue5 extends RenderType5 { override def toString = "boldunderline" }
case object DoublequoteValue5 extends RenderType5 { override def toString = "doublequote" }
case object ItalicValue5 extends RenderType5 { override def toString = "italic" }
case object NonproportValue5 extends RenderType5 { override def toString = "nonproport" }
case object SinglequoteValue5 extends RenderType5 { override def toString = "singlequote" }
case object SmcapsValue5 extends RenderType5 { override def toString = "smcaps" }
case object SubValue5 extends RenderType5 { override def toString = "sub" }
case object SuperValue5 extends RenderType5 { override def toString = "super" }
case object UnderlineValue5 extends RenderType5 { override def toString = "underline" }

sealed trait LevelType

object LevelType {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[LevelType]): LevelType = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: LevelType) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[LevelType] = Seq(ClassValue, CollectionValue, FileValue, FondsValue, ItemValue2, OtherlevelValue, RecordgrpValue, SeriesValue, SubfondsValue, SubgrpValue, SubseriesValue)
}

case object ClassValue extends LevelType { override def toString = "class" }
case object CollectionValue extends LevelType { override def toString = "collection" }
case object FileValue extends LevelType { override def toString = "file" }
case object FondsValue extends LevelType { override def toString = "fonds" }
case object ItemValue2 extends LevelType { override def toString = "item" }
case object OtherlevelValue extends LevelType { override def toString = "otherlevel" }
case object RecordgrpValue extends LevelType { override def toString = "recordgrp" }
case object SeriesValue extends LevelType { override def toString = "series" }
case object SubfondsValue extends LevelType { override def toString = "subfonds" }
case object SubgrpValue extends LevelType { override def toString = "subgrp" }
case object SubseriesValue extends LevelType { override def toString = "subseries" }

sealed trait Unitdatetype

object Unitdatetype {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Unitdatetype]): Unitdatetype = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Unitdatetype) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Unitdatetype] = Seq(Bulk, Inclusive)
}

case object Bulk extends Unitdatetype { override def toString = "bulk" }
case object Inclusive extends Unitdatetype { override def toString = "inclusive" }

sealed trait CoverageType3

object CoverageType3 {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[CoverageType3]): CoverageType3 = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: CoverageType3) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[CoverageType3] = Seq(WholeValue3, PartValue4)
}

case object WholeValue3 extends CoverageType3 { override def toString = "whole" }
case object PartValue4 extends CoverageType3 { override def toString = "part" }

sealed trait Avu46boolean

object Avu46boolean {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[Avu46boolean]): Avu46boolean = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: Avu46boolean) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[Avu46boolean] = Seq(True, False)
}

case object True extends Avu46boolean { override def toString = "true" }
case object False extends Avu46boolean { override def toString = "false" }

trait Mu46mixedu46basicu46plusu46elementsOption
trait Mu46mixedu46basicu46elementsOption
trait Mu46didOption
trait Mu46accessOption
trait Mu46interu46noquoteOption
trait Mu46blocksOption
trait Mu46interOption
trait Mu46cOrC01Option
trait Mu46descu46baseOption
trait Mu46refsOption
trait Mu46mixedu46basicu46dateu46elementsOption

case class Au46transliteration(transliteration: String)


case class Au46coverage(coverage: CoverageType3)


case class Au46colsep(colsep: Avu46boolean)


case class Au46charoff(charoff: String)


case class Au46unitdatetype(unitdatetype: Option[Unitdatetype] = None)


case class Au46localtype(localtype: String)


case class Au46encodinganalog(encodinganalog: String)


case class Au46certainty(certainty: String)


case class Au46lastdatetimeverified(lastdatetimeverified: String)


case class Amu46datesu46era(era: Option[String] = None)


case class Au46label(label: String)


case class Au46valign(valign: ValignType4)


case class Au46entityref(entityref: String)


case class Au46relator(relator: String)


case class Au46identifier(identifier: String)


case class Au46linku46title(linktitle: String)


case class Au46linku46role(linkrole: java.net.URI)


case class Au46linku46arcrole(arcrole: java.net.URI)


case class Amu46accessu46nou46normal(source: Option[String] = None,
  rules: Option[String] = None,
  identifier: Option[String] = None)


case class Amu46descu46c(id: Option[String] = None,
  altrender: Option[String] = None,
  audience: Option[Audience] = None,
  lang: Option[String] = None,
  script: Option[String] = None,
  base: Option[java.net.URI] = None,
  level: Option[Level] = None,
  otherlevel: Option[String] = None,
  encodinganalog: Option[String] = None)


case class Amu46common(id: Option[String] = None,
  altrender: Option[String] = None,
  audience: Option[Audience] = None,
  lang: Option[String] = None,
  script: Option[String] = None)


case class Amu46simplelink(href: Option[String] = None,
  linkrole: Option[java.net.URI] = None,
  arcrole: Option[java.net.URI] = None,
  linktitle: Option[String] = None,
  show: Option[ShowType] = None,
  actuate: Option[ActuateType] = None)


case class Amu46internalu46ptr(target: Option[String] = None,
  xpointer: Option[String] = None,
  href: Option[String] = None,
  linkrole: Option[java.net.URI] = None,
  arcrole: Option[java.net.URI] = None,
  linktitle: Option[String] = None,
  show: Option[ShowType] = None,
  actuate: Option[ActuateType] = None)


case class Amu46commonu46empty(id: Option[String] = None,
  altrender: Option[String] = None,
  audience: Option[Audience] = None)


case class Amu46descu46base(otherlevel: Option[String] = None,
  encodinganalog: Option[String] = None)


case class Amu46access(source: Option[String] = None,
  rules: Option[String] = None,
  identifier: Option[String] = None,
  normal: Option[String] = None)


case class Au46linku46actuate(actuate: ActuateType2)


case class Au46linku46href(href: String)


case class Au46linku46show(show: ShowType2)


case class Au46base(base: java.net.URI)


case class Au46parent(parent: Seq[String])


case class Au46linku46xpointer(xpointer: String)


case class Au46align(align: AlignType3)


case class Au46render(render: RenderType5)


case class Amu46datesu46calendar(calendar: Option[String] = None)


case class Amu46dateu46normal(normal: Option[String] = None)


case class Au46datechar(datechar: String)


case class Au46normal(normal: String)


case class Au46level(level: LevelType)


case class Au46relatedencoding(relatedencoding: String)


case class Au46char(char: String)


case class Au46colname(colname: String)


case class Au46rowsep(rowsep: Avu46boolean)


case class Amu46countrycode(countrycode: Option[String] = None)

